﻿using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 弓兵AI : AI
    {
        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            #region 箭雨

            if (技能mgt.Has("箭雨"))
            {
                int 几率 = 0;
                switch (角色.行动点)
                {
                    case 1:
                        几率 = 100;
                        break;
                    case 2:
                        几率 = 70;
                        break;
                    case 3:
                        几率 = 40;
                        break;
                    default:
                        几率 = 20;
                        break;
                }
                var 箭雨 = 技能mgt.Get("箭雨");
                switch (箭雨.TargetList[0].List.Count)
                { 
                    case 1:
                        几率 -= 100;
                        break;
                    case 2:
                        几率 -= 60;
                        break;
                }

                bool hit = false;
                if (几率 == 100)
                    hit = true;
                else if(几率 > 0)
                    hit = 队伍状况.战场.AI乱数表.Hit(几率);

                if (hit)
                {
                    
                    result.Action = 箭雨.Name;
                    result.TargetList = 箭雨.TargetList[0].List;

                    return result;
                }
            }

            #endregion

            #region 弩炮

            if (技能mgt.Has("弩炮") && 角色.行动点 >= 2)
            {
                var 弩炮 = 技能mgt.Get("弩炮");
                result.Action = 弩炮.Name;
                var targetList = get弩炮TargetList(弩炮.TargetList, 队伍状况, 角色);
                if (targetList != null)
                {
                    result.TargetList = targetList;
                    return result;
                }
            }

            #endregion

            #region 弓箭射击

            var 弓箭射击 = 技能mgt.Get("弓箭射击");
            var 弓箭射击target = getTarget(ConvertSoloTarget(弓箭射击.TargetList), 队伍状况, 角色);
            result.Action = 弓箭射击.Name;
            result.TargetList.Add(弓箭射击target);

            return result;

            #endregion
        }

        private 角色 getTarget(List<角色> targetList, 队伍状况 队伍状况, 角色 角色)
        {
            //优先攻击"准备中"的敌人
            var 准备角色List = 队伍状况.对手状态.队伍.成员List.FindAll(r => r.是否准备);
            if (准备角色List.Count > 0)
            {
                准备角色List.Sort((v1, v2) => v1.兵力.CompareTo(v2.兵力));
                准备角色List.Reverse();

                return 准备角色List[0];
            }


            //撇除"步卒"敌人
            List<角色> tempList = new List<角色>();
            foreach (var item in targetList)
            {
                if (item.兵种.类型 == "步卒")
                    continue;

                tempList.Add(item);
            }

            if (tempList.Count != 0)
                targetList = tempList;

            if (targetList.Count == 1)
                return targetList[0];
            else
            {
                //优先攻击准备中的敌人

                List<角色> temp2List = new List<角色>();
                foreach (var item in tempList)
                {
                    if (item.是否准备)
                    {
                        tempList.Add(item);
                        break;
                    }
                }
                if (temp2List.Count == 1)
                    return temp2List[0];


                //有"阻击剑士"时,优先攻击剑士
                if (角色.被动技能 != null && 角色.被动技能.Name == "阻击剑士")
                {
                    temp2List.Clear();
                    foreach (var item in tempList)
                    {
                        if (item.兵种.类型 == "剑士")
                        {
                            tempList.Add(item);
                            break;
                        }
                    }

                    if (temp2List.Count == 1)
                        return temp2List[0];
                    else if (temp2List.Count > 1)
                    {
                        var value1 = 队伍状况.战场.AI乱数表.Random(0, temp2List.Count);
                        return temp2List[value1];
                    }
                }

                var value = 队伍状况.战场.AI乱数表.Random(0, targetList.Count);
                return targetList[value];
            }
        }

        private List<角色> get弩炮TargetList(List<AI技能目标> list, 队伍状况 队伍状况, 角色 角色)
        {

            list = list.FindAll(r => r.List.Count == 2);
            if (list.Count == 0)
                return null;

            var 准备角色List = 队伍状况.对手状态.队伍.成员List.FindAll(r => r.是否准备);
            if (准备角色List.Count > 0)
            {
                准备角色List.Sort((v1, v2) => v1.兵力.CompareTo(v2.兵力));
                准备角色List.Reverse();

                foreach (var item in 准备角色List)
                {
                    AI技能目标 ai技能目标 = list.Find(r => r.List.Contains(item));
                    if(ai技能目标 != null)
                        return ai技能目标.List;
                }

                return null;
            }

            //撇除步卒
            List<List<角色>> tempList = new List<List<角色>>();
            foreach (var item in list)
            {
                bool has步卒 = false;
                foreach (var item1 in item.List)
                {
                    if (item1.兵种.类型 == "步卒")
                    {
                        has步卒 = true;
                        break;
                    }
                }
                if (!has步卒)
                    tempList.Add(item.List);
            }

            if (tempList.Count == 0)
            {
                foreach (var item in list)
                    tempList.Add(item.List);
            }

            if (tempList.Count == 1)
                return tempList[0];
            else
            {
                //有"阻击剑士"时,优先攻击剑士
                if (角色.被动技能 != null && 角色.被动技能.Name == "阻击剑士")
                {
                    List<List<角色>> temp2List = new List<List<角色>>();
                    foreach (var item in tempList)
                    {
                        foreach (var item1 in item)
                        {
                            if (item1.兵种.类型 == "剑士")
                            {
                                tempList.Add(item);
                                break;
                            }
                        }
                    }

                    if (temp2List.Count == 1)
                        return temp2List[0];
                    else if (temp2List.Count > 1)
                    {
                        var value1 = 队伍状况.战场.AI乱数表.Random(0, temp2List.Count);
                        return temp2List[value1];
                    }
                }

                var value = 队伍状况.战场.AI乱数表.Random(0, tempList.Count);
                return tempList[value];
            }
        }

        private static 弓兵AI instance = new 弓兵AI();
        public static 弓兵AI GetInstance()
        {
            return instance;
        }
    }
}
